//-----------------------------------------------------------------------------
//  Copyright (C) 2011-2018, GB Research, LLC (www.gbresearch.com)
//  
//  Boost Software License - Version 1.0 - August 17th, 2003
//
//  Permission is hereby granted, free of charge, to any person or organization
//  obtaining a copy of the software and accompanying documentation covered by
//  this license (the "Software") to use, reproduce, display, distribute,
//  execute, and transmit the Software, and to prepare derivative works of the
//  Software, and to permit third-parties to whom the Software is furnished to
//  do so, all subject to the following:
//
//  The copyright notices in the Software and this entire statement, including
//  the above license grant, this restriction and the following disclaimer,
//  must be included in all copies of the Software, in whole or in part, and
//  all derivative works of the Software, unless such copies or derivative
//  works are solely in the form of machine-executable object code generated by
//  a source language processor.
//
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//  FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
//  SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
//  FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
//  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
//  DEALINGS IN THE SOFTWARE.
//-----------------------------------------------------------------------------

#pragma once

#include "axe_numeric.h"

namespace axe
{

    //-------------------------------------------------------------------------
    /// r_udecimal rule for matching unsigned decimal
    //-------------------------------------------------------------------------
    template<class T>
    inline r_udecimal_t<T> r_udecimal(T& t) { return r_udecimal_t<T>(t); }

    inline r_udecimal_t<> r_udecimal() { return r_udecimal_t<>(); }

    //-------------------------------------------------------------------------
    /// r_decimal rule for matching signed decimal
    //-------------------------------------------------------------------------
    template<class T>
    inline r_decimal_t<T> r_decimal(T& t) { return r_decimal_t<T>(t); }

    inline r_decimal_t<> r_decimal() { return r_decimal_t<>(); }

    //-------------------------------------------------------------------------
    /// r_hex rule for matching unsigned decimal in hex format
    //-------------------------------------------------------------------------
    template<class T>
    inline r_hex_t<T> r_hex(T& t) { return r_hex_t<T>(t); }

    //-------------------------------------------------------------------------
    /// r_hex rule for matching unsigned decimal in oct format
    //-------------------------------------------------------------------------
    template<class T>
    inline r_oct_t<T> r_oct(T& t) { return r_oct_t<T>(t); }

    //-------------------------------------------------------------------------
    /// r_hex rule for matching unsigned decimal in bin format
    //-------------------------------------------------------------------------
    template<class T>
    inline r_binary_t<T> r_binary(T& t) { return r_binary_t<T>(t); }

    //-------------------------------------------------------------------------
    /// r_ufixed rule for matching unsigned fixed point number
    //-------------------------------------------------------------------------
    template<class T>
    inline r_ufixed_t<T> r_ufixed(T& t) { return r_ufixed_t<T>(t); }

    inline r_ufixed_t<> r_ufixed() { return r_ufixed_t<>(); }

    //-------------------------------------------------------------------------
    /// r_fixed rule for matching signed fixed point number
    //-------------------------------------------------------------------------
    template<class T>
    inline r_fixed_t<T> r_fixed(T& t) { return r_fixed_t<T>(t); }

    inline r_fixed_t<> r_fixed() { return r_fixed_t<>(); }

    //-------------------------------------------------------------------------
    /// r_double rule for matching double precision number
    //-------------------------------------------------------------------------
    template<class T>
    inline r_double_t<T> r_double(T& d) { return r_double_t<T>(d); }

    inline r_double_t<> r_double() { return r_double_t<>(); }
}
